home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / src / EvalMod.mi < prev    next >
Text File  |  1992-11-24  |  21KB  |  750 lines
  1. IMPLEMENTATION MODULE EvalMod;
  2.  
  3.  
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  
  10.  
  11.  
  12.  
  13.  
  14.  
  15. IMPORT SYSTEM, System, IO, Tree;
  16. (* line 9 "" *)
  17.  
  18.  
  19. FROM SYSTEM    IMPORT ADR;
  20. FROM IO        IMPORT WriteS, WriteNl;
  21. FROM StringMem    IMPORT WriteString;
  22. FROM Texts    IMPORT WriteText;
  23. FROM Sets    IMPORT IsElement;
  24. FROM TreeMod1    IMPORT BSS;
  25. FROM TreeMod2    IMPORT WriteLine;
  26. FROM EvalMod3    IMPORT ToBit0;
  27.  
  28. FROM Tree    IMPORT
  29.    NoTree    , tTree        , Child        , NoCodeClass    ,
  30.    Computed    , Reverse    , Write        , Read        ,
  31.    Inherited    , Synthesized    , Input        , Output    ,
  32.    CopyDef    , CopyUse    , Thread    , Virtual    ,
  33.    Test        , Left        , Right        ,
  34.    NonBaseComp    , First        , Dummy        , Trace        ,
  35.    Options    , TreeRoot    , iModule    , iMain        ,
  36.    itTree    , ForallClasses    , f        , WI    , WN    ,
  37.    IdentifyClass, IdentifyAttribute, GrammarClass, cOAG        ,
  38.    MaxVisit    ;
  39.  
  40. VAR
  41.    n        : SHORTCARD;
  42.    Node        ,
  43.    Attr        ,
  44.    ChildsClass    : tTree;
  45.  
  46.  
  47.  
  48.  
  49.  
  50.  
  51.  
  52.  
  53.  
  54.  
  55.  
  56.  
  57.  
  58.  
  59.  
  60.  
  61.  
  62.  
  63.  
  64.  
  65.  
  66.  
  67.  
  68.  
  69.  
  70.  
  71.  
  72.  
  73.  
  74.  
  75.  
  76.  
  77.  
  78.  
  79.  
  80.  
  81.  
  82.  
  83.  
  84.  
  85.  
  86.  
  87.  
  88.  
  89.  
  90.  
  91.  
  92.  
  93.  
  94.  
  95.  
  96.  
  97.  
  98.  
  99.  
  100.  
  101.  
  102.  
  103.  
  104.  
  105.  
  106.  
  107.  
  108.  
  109.  
  110.  
  111.  
  112.  
  113.  
  114.  
  115.  
  116.  
  117.  
  118.  
  119.  
  120.  
  121.  
  122.  
  123.  
  124.  
  125.  
  126.  
  127.  
  128.  
  129.  
  130.  
  131.  
  132.  
  133.  
  134.  
  135.  
  136.  
  137.  
  138.  
  139.  
  140.  
  141.  
  142.  
  143.  
  144.  
  145.  
  146.  
  147.  
  148.  
  149.  
  150.  
  151. PROCEDURE yyAbort (yyFunction: ARRAY OF CHAR);
  152.  BEGIN
  153.   IO.WriteS (IO.StdError, 'Error: module EvalMod, routine ');
  154.   IO.WriteS (IO.StdError, yyFunction);
  155.   IO.WriteS (IO.StdError, ' failed');
  156.   IO.WriteNl (IO.StdError);
  157.   Exit;
  158.  END yyAbort;
  159.  
  160. PROCEDURE yyIsEqual (yya, yyb: ARRAY OF SYSTEM.BYTE): BOOLEAN;
  161.  VAR yyi    : INTEGER;
  162.  BEGIN
  163.   FOR yyi := 0 TO INTEGER (HIGH (yya)) DO
  164.    IF yya [yyi] # yyb [yyi] THEN RETURN FALSE; END;
  165.   END;
  166.   RETURN TRUE;
  167.  END yyIsEqual;
  168.  
  169. PROCEDURE EvalDefMod (t: Tree.tTree);
  170.  VAR yyTempo: RECORD CASE : INTEGER OF
  171.  END; END;
  172.  BEGIN
  173.   IF t = Tree.NoTree THEN RETURN; END;
  174.   IF (t^.Kind = Tree.Ag) THEN
  175. (* line 41 "" *)
  176.      WITH t^.Ag DO
  177. (* line 41 "" *)
  178.       
  179.     WriteS (f, "DEFINITION MODULE "); WI (EvalName); WriteS (f, ";"); WriteNl (f);
  180.     WriteNl (f);
  181.     WriteS (f, "IMPORT "); WI (iMain); WriteS (f, ";"); WriteNl (f);
  182.     WriteLine (EvalCodes^.Codes.ImportLine);
  183.     WriteText (f, EvalCodes^.Codes.Import);
  184.     Node := Modules;
  185.     WHILE Node^.Kind = Tree.Module DO
  186.        WriteLine (Node^.Module.EvalCodes^.Codes.ImportLine);
  187.        WriteText (f, Node^.Module.EvalCodes^.Codes.Import);
  188.        Node := Node^.Module.Next;
  189.     END;
  190.     WriteLine (EvalCodes^.Codes.ExportLine);
  191.     WriteText (f, EvalCodes^.Codes.Export);
  192.     Node := Modules;
  193.     WHILE Node^.Kind = Tree.Module DO
  194.        WriteLine (Node^.Module.EvalCodes^.Codes.ExportLine);
  195.        WriteText (f, Node^.Module.EvalCodes^.Codes.Export);
  196.        Node := Node^.Module.Next;
  197.     END;
  198.     WriteNl (f);
  199.     WriteS (f, "PROCEDURE Eval (yyt: "); WI (iMain); WriteS (f, "."); WI (itTree); WriteS (f, ");"); WriteNl (f);
  200.     WriteS (f, "PROCEDURE Begin"); WI (EvalName); WriteS (f, ";"); WriteNl (f);
  201.     WriteS (f, "PROCEDURE Close"); WI (EvalName); WriteS (f, ";"); WriteNl (f);
  202.     WriteNl (f);
  203.     WriteS (f, "END "); WI (EvalName); WriteS (f, "."); WriteNl (f);
  204. ;
  205.       RETURN;
  206.      END;
  207.  
  208.   END;
  209.  END EvalDefMod;
  210.  
  211. PROCEDURE EvalImplHead (t: Tree.tTree);
  212.  VAR yyTempo: RECORD CASE : INTEGER OF
  213.  END; END;
  214.  BEGIN
  215.   IF t = Tree.NoTree THEN RETURN; END;
  216.   IF (t^.Kind = Tree.Ag) THEN
  217. (* line 71 "" *)
  218.      WITH t^.Ag DO
  219. (* line 71 "" *)
  220.       
  221.     WriteS (f, "# define DEP(a, b) a"); WriteNl (f);
  222.     WriteS (f, "# define SELF yyt"); WriteNl (f);
  223.     WriteS (f, "IMPLEMENTATION MODULE "); WI (EvalName); WriteS (f, ";"); WriteNl (f);
  224.     WriteNl (f);
  225.     WriteS (f, "IMPORT SYSTEM, "); WI (iMain); WriteS (f, ";"); WriteNl (f);
  226.       IF IsElement (ORD ('Y'), Options) OR
  227.          IsElement (ORD ('Z'), Options) THEN
  228.     WriteS (f, "IMPORT Layout, Strings, Idents, Texts, Sets;"); WriteNl (f);
  229.       END;
  230.       IF IsElement (ORD ('Y'), Options) OR
  231.          IsElement (ORD ('Z'), Options) OR
  232.          IsElement (ORD ('L'), Options) OR
  233.          IsElement (ORD ('9'), Options) THEN
  234.     WriteS (f, "IMPORT IO;"); WriteNl (f);
  235.       END;
  236.       IF IsElement (ORD ('9'), Options) THEN
  237.     WriteS (f, "IMPORT General;"); WriteNl (f);
  238.       END;
  239.     WriteLine (EvalCodes^.Codes.GlobalLine);
  240.     WriteText (f, EvalCodes^.Codes.Global);
  241.     Node := Modules;
  242.     WHILE Node^.Kind = Tree.Module DO
  243.        WriteLine (Node^.Module.EvalCodes^.Codes.GlobalLine);
  244.        WriteText (f, Node^.Module.EvalCodes^.Codes.Global);
  245.        Node := Node^.Module.Next;
  246.     END;
  247.     WriteNl (f);
  248.     WriteS (f, "VAR yyb    : BOOLEAN;"); WriteNl (f);
  249.       IF IsElement (ORD ('X'), Options) THEN
  250.     WriteS (f, '# include "yy'); WI (iModule); WriteS (f, '.w"'); WriteNl (f);
  251.     WriteS (f, "# define yyWrite"); WI (iMain); WriteS (f, "(a) "); WI (iMain); WriteS (f, ".Write"); WI (iMain); WriteS (f, " (yyf, a)"); WriteNl (f);
  252.     WriteNl (f);
  253.     WriteS (f, "VAR yyf    : IO.tFile;"); WriteNl (f);
  254.     WriteNl (f);
  255.     WriteS (f, "PROCEDURE yyWriteHex (VAR yyx: ARRAY OF SYSTEM.BYTE);"); WriteNl (f);
  256.     WriteS (f, " VAR yyi    : INTEGER;"); WriteNl (f);
  257.     WriteS (f, " BEGIN"); WriteNl (f);
  258.     WriteS (f, "  IF yyTrace THEN"); WriteNl (f);
  259.     WriteS (f, "   FOR yyi := 0 TO INTEGER (HIGH (yyx)) DO"); WriteNl (f);
  260.     WriteS (f, "    IO.WriteN (yyf, ORD (CHAR (yyx [yyi])), 2, 16);"); WriteNl (f);
  261.     WriteS (f, "    IO.WriteC (yyf, ' ');"); WriteNl (f);
  262.     WriteS (f, "   END;"); WriteNl (f);
  263.     WriteS (f, "  END;"); WriteNl (f);
  264.     WriteS (f, " END yyWriteHex;"); WriteNl (f);
  265.     WriteNl (f);
  266.     WriteS (f, "PROCEDURE yyWriteNl;"); WriteNl (f);
  267.     WriteS (f, " BEGIN IF yyTrace THEN"); WriteNl (f);
  268.     WriteS (f, "  IO.WriteNl (IO.StdOutput); IO.WriteFlush (IO.StdOutput);"); WriteNl (f);
  269.     WriteS (f, " END; END yyWriteNl;"); WriteNl (f);
  270.       END;
  271.       IF IsElement (ORD ('Y'), Options) OR
  272.          IsElement (ORD ('Z'), Options) THEN
  273.     WriteNl (f);
  274.     WriteS (f, "CONST yyTrace = TRUE;"); WriteNl (f);
  275.     WriteNl (f);
  276.     WriteS (f, "PROCEDURE yyWriteS (yys: ARRAY OF CHAR);"); WriteNl (f);
  277.     WriteS (f, " BEGIN"); WriteNl (f);
  278.     WriteS (f, "  IO.WriteS (IO.StdOutput, yys); Layout.WriteSpaces (IO.StdOutput, 15 - INTEGER (HIGH (yys)));"); WriteNl (f);
  279.     WriteS (f, " END yyWriteS;"); WriteNl (f);
  280.     WriteNl (f);
  281.     WriteS (f, "PROCEDURE yyWriteType (yyt: "); WI (iMain); WriteS (f, "."); WI (itTree); WriteS (f, ");"); WriteNl (f);
  282.     WriteS (f, " BEGIN"); WriteNl (f);
  283.     WriteS (f, "  CASE yyt^.Kind OF"); WriteNl (f);
  284.     ForallClasses (Classes, WriteType);
  285.     WriteS (f, "  ELSE"); WriteNl (f);
  286.     WriteS (f, "  END;"); WriteNl (f);
  287.     WriteS (f, " END yyWriteType;"); WriteNl (f);
  288.       END;
  289.       IF IsElement (ORD ('X'), Options) THEN
  290.     WriteNl (f);
  291.     WriteS (f, "PROCEDURE yyWriteEval (yyt: "); WI (iMain); WriteS (f, "."); WI (itTree); WriteS (f, "; yys: ARRAY OF CHAR);"); WriteNl (f);
  292.     WriteS (f, " BEGIN"); WriteNl (f);
  293.     WriteS (f, "  IF yyTrace THEN"); WriteNl (f);
  294.     WriteS (f, "   yyWriteType (yyt);"); WriteNl (f);
  295.     WriteS (f, "   IO.WriteS (IO.StdOutput, ' e ');"); WriteNl (f);
  296.     WriteS (f, "   IO.WriteS (IO.StdOutput, yys);"); WriteNl (f);
  297.     WriteS (f, "   Layout.WriteSpaces (IO.StdOutput, 23 - INTEGER (HIGH (yys)));"); WriteNl (f);
  298.     WriteS (f, "   IO.WriteS (IO.StdOutput, ' = ');"); WriteNl (f);
  299.     WriteS (f, "   IO.WriteFlush (IO.StdOutput);"); WriteNl (f);
  300.     WriteS (f, "  END;"); WriteNl (f);
  301.     WriteS (f, " END yyWriteEval;"); WriteNl (f);
  302.       ELSIF IsElement (ORD ('Y'), Options) THEN
  303.     WriteNl (f);
  304.     WriteS (f, "PROCEDURE yyWriteEval (yyt: "); WI (iMain); WriteS (f, "."); WI (itTree); WriteS (f, "; yys: ARRAY OF CHAR);"); WriteNl (f);
  305.     WriteS (f, " BEGIN"); WriteNl (f);
  306.     WriteS (f, "  IF yyTrace THEN"); WriteNl (f);
  307.     WriteS (f, "   yyWriteType (yyt);"); WriteNl (f);
  308.     WriteS (f, "   IO.WriteS (IO.StdOutput, ' e ');"); WriteNl (f);
  309.     WriteS (f, "   IO.WriteS (IO.StdOutput, yys);"); WriteNl (f);
  310.     WriteS (f, "   IO.WriteNl (IO.StdOutput);"); WriteNl (f);
  311.     WriteS (f, "   IO.WriteFlush (IO.StdOutput);"); WriteNl (f);
  312.     WriteS (f, "  END;"); WriteNl (f);
  313.     WriteS (f, " END yyWriteEval;"); WriteNl (f);
  314.       END;
  315.       IF IsElement (ORD ('Z'), Options) THEN
  316.     WriteNl (f);
  317.     WriteS (f, "PROCEDURE yyWriteVisit (yyt: "); WI (iMain); WriteS (f, "."); WI (itTree); WriteS (f, "; yys: ARRAY OF CHAR);"); WriteNl (f);
  318.     WriteS (f, " BEGIN"); WriteNl (f);
  319.     WriteS (f, "  IF yyTrace THEN"); WriteNl (f);
  320.     WriteS (f, "   yyWriteType (yyt);"); WriteNl (f);
  321.     WriteS (f, "   IO.WriteS (IO.StdOutput, ' v ');"); WriteNl (f);
  322.     WriteS (f, "   IO.WriteS (IO.StdOutput, yys);"); WriteNl (f);
  323.     WriteS (f, "   IO.WriteNl (IO.StdOutput);"); WriteNl (f);
  324.     WriteS (f, "   IO.WriteFlush (IO.StdOutput);"); WriteNl (f);
  325.     WriteS (f, "  END;"); WriteNl (f);
  326.     WriteS (f, " END yyWriteVisit;"); WriteNl (f);
  327.     WriteNl (f);
  328.     WriteS (f, "PROCEDURE yyVisitParent (yyt: "); WI (iMain); WriteS (f, "."); WI (itTree); WriteS (f, ");"); WriteNl (f);
  329.     WriteS (f, " BEGIN yyWriteVisit (yyt, 'parent'); END yyVisitParent;"); WriteNl (f);
  330.       END;
  331. ;
  332.       RETURN;
  333.      END;
  334.  
  335.   END;
  336.  END EvalImplHead;
  337.  
  338. PROCEDURE EvalImplMod (t: Tree.tTree);
  339.  VAR yyTempo: RECORD CASE : INTEGER OF
  340.  END; END;
  341.  BEGIN
  342.   IF t = Tree.NoTree THEN RETURN; END;
  343.   IF (t^.Kind = Tree.Ag) THEN
  344. (* line 186 "" *)
  345.      WITH t^.Ag DO
  346. (* line 186 "" *)
  347.       
  348.     EvalImplHead (t);
  349.       IF NOT IsElement (ORD ('9'), Options) THEN
  350.     WriteNl (f);
  351.     WriteS (f, "PROCEDURE Eval (yyt: "); WI (iMain); WriteS (f, "."); WI (itTree); WriteS (f, ");"); WriteNl (f);
  352.     WriteS (f, " BEGIN "); 
  353.     IF MaxVisit > 0 THEN WriteS (f, "yyVisit1 (yyt); "); END;
  354.     WriteS (f, "END Eval;"); WriteNl (f);
  355.       ELSE
  356.     WriteNl (f);
  357.     WriteS (f, "VAR xxStack: CARDINAL;"); WriteNl (f);
  358.     WriteNl (f);
  359.     WriteS (f, "PROCEDURE Eval (yyt: "); WI (iMain); WriteS (f, "."); WI (itTree); WriteS (f, ");"); WriteNl (f);
  360.     WriteS (f, " VAR xxHigh: BOOLEAN;"); WriteNl (f);
  361.     WriteS (f, " BEGIN"); WriteNl (f);
  362.     WriteS (f, "  xxStack := MAX (INTEGER);"); WriteNl (f);
  363.     IF MaxVisit > 0 THEN
  364.     WriteS (f, "  yyVisit1 (yyt);"); WriteNl (f);
  365.     END;
  366.     WriteS (f, "  IO.WriteS (IO.StdOutput, 'Stacksize ');"); WriteNl (f);
  367.     WriteS (f, "  IO.WriteI (IO.StdOutput, CARDINAL (SYSTEM.ADR (xxHigh)) - xxStack, 0);"); WriteNl (f);
  368.     WriteS (f, "  IO.WriteNl (IO.StdOutput);"); WriteNl (f);
  369.     WriteS (f, " END Eval;"); WriteNl (f);
  370.       END;
  371.     WriteNl (f);
  372.     FOR n := 1 TO MaxVisit DO
  373.        WriteS (f, "PROCEDURE yyVisit"); WN (n); WriteS (f, " (yyt: "); WI (iMain); WriteS (f, "."); WI (itTree); WriteS (f, ");"); WriteNl (f);
  374.        WriteLine (EvalCodes^.Codes.LocalLine);
  375.        WriteText (f, EvalCodes^.Codes.Local);
  376.        Node := Modules;
  377.        WHILE Node^.Kind = Tree.Module DO
  378.           WriteLine (Node^.Module.EvalCodes^.Codes.LocalLine);
  379.           WriteText (f, Node^.Module.EvalCodes^.Codes.Local);
  380.           Node := Node^.Module.Next;
  381.        END;
  382.       IF IsElement (ORD ('9'), Options) THEN
  383.        WriteS (f, " VAR xxLow: BOOLEAN;"); WriteNl (f);
  384.        WriteS (f, " BEGIN"); WriteNl (f);
  385.        WriteS (f, "  xxStack := General.Min (xxStack, CARDINAL (SYSTEM.ADR (xxLow)));"); WriteNl (f);
  386.       ELSE
  387.        WriteS (f, " BEGIN"); WriteNl (f);
  388.       END;
  389.        WriteS (f, "  CASE yyt^.Kind OF"); WriteNl (f);
  390.        IF cOAG IN GrammarClass THEN        (* generate evaluator    *)
  391.           ForallClasses (Classes, GenEvaluator);
  392.        END;
  393.        WriteS (f, "  ELSE"); WriteNl (f);
  394.       IF IsElement (ORD ('Z'), Options) THEN
  395.        WriteS (f, "   yyVisitParent (yyt);"); WriteNl (f);
  396.       END;
  397.        WriteS (f, "  END;"); WriteNl (f);
  398.        WriteS (f, " END yyVisit"); WN (n); WriteS (f, ";"); WriteNl (f);
  399.        WriteNl (f);
  400.     END;
  401.     WriteS (f, "PROCEDURE Begin"); WI (EvalName); WriteS (f, ";"); WriteNl (f);
  402.     WriteS (f, " BEGIN"); WriteNl (f);
  403.     WriteLine (EvalCodes^.Codes.BeginLine);
  404.     WriteText (f, EvalCodes^.Codes.Begin);
  405.     Node := Modules;
  406.     WHILE Node^.Kind = Tree.Module DO
  407.        WriteLine (Node^.Module.EvalCodes^.Codes.BeginLine);
  408.        WriteText (f, Node^.Module.EvalCodes^.Codes.Begin);
  409.        Node := Node^.Module.Next;
  410.     END;
  411.     WriteS (f, " END Begin"); WI (EvalName); WriteS (f, ";"); WriteNl (f);
  412.     WriteNl (f);
  413.     WriteS (f, "PROCEDURE Close"); WI (EvalName); WriteS (f, ";"); WriteNl (f);
  414.     WriteS (f, " BEGIN"); WriteNl (f);
  415.     WriteLine (EvalCodes^.Codes.CloseLine);
  416.     WriteText (f, EvalCodes^.Codes.Close);
  417.     Node := Modules;
  418.     WHILE Node^.Kind = Tree.Module DO
  419.        WriteLine (Node^.Module.EvalCodes^.Codes.CloseLine);
  420.        WriteText (f, Node^.Module.EvalCodes^.Codes.Close);
  421.        Node := Node^.Module.Next;
  422.     END;
  423.     WriteS (f, " END Close"); WI (EvalName); WriteS (f, ";"); WriteNl (f);
  424.     WriteNl (f);
  425.     WriteS (f, "BEGIN"); WriteNl (f);
  426.       IF IsElement (ORD ('X'), Options) THEN
  427.     WriteS (f, " yyf := IO.StdOutput;"); WriteNl (f);
  428.       END;
  429.     WriteS (f, "END "); WI (EvalName); WriteS (f, "."); WriteNl (f);
  430. ;
  431.       RETURN;
  432.      END;
  433.  
  434.   END;
  435.  END EvalImplMod;
  436.  
  437. PROCEDURE WriteType (t: Tree.tTree);
  438.  VAR yyTempo: RECORD CASE : INTEGER OF
  439.  END; END;
  440.  BEGIN
  441.   IF t = Tree.NoTree THEN RETURN; END;
  442.   IF (t^.Kind = Tree.Class) THEN
  443. (* line 274 "" *)
  444.    LOOP
  445.      WITH t^.Class DO
  446. (* line 275 "" *)
  447.       IF NOT (NoCodeClass * Properties = {}) THEN EXIT; END;
  448. (* line 276 "" *)
  449.       IF NOT (Trace IN Properties) THEN EXIT; END;
  450. (* line 277 "" *)
  451.       WriteS (f, "| ");
  452. (* line 277 "" *)
  453.       WI (TreeRoot ^ . Ag . TreeName);
  454. (* line 277 "" *)
  455.       WriteS (f, ".");
  456. (* line 277 "" *)
  457.       WI (Name);
  458. (* line 277 "" *)
  459.       WriteS (f, ": yyWriteS ('");
  460. (* line 277 "" *)
  461.       WI (Name);
  462. (* line 277 "" *)
  463.       WriteS (f, "');");
  464. (* line 277 "" *)
  465.       WriteNl (f);
  466.       RETURN;
  467.      END;
  468.    END;
  469.  
  470.   END;
  471.  END WriteType;
  472.  
  473. PROCEDURE GenEvaluator (t: Tree.tTree);
  474.  VAR yyTempo: RECORD CASE : INTEGER OF
  475.  | 8: yyR8: RECORD
  476.   TheClass: Tree.tTree;
  477.   k: INTEGER;
  478.   END;
  479.  END; END;
  480.  BEGIN
  481.   IF t = Tree.NoTree THEN RETURN; END;
  482.  
  483.   CASE t^.Kind OF
  484.   | Tree.Class:
  485. (* line 282 "" *)
  486.    LOOP
  487.      WITH t^.Class DO
  488. (* line 283 "" *)
  489.       IF NOT (NoCodeClass * Properties = {}) THEN EXIT; END;
  490. (* line 284 "" *)
  491.           IF (Generated = InstCount) OR (Visits < n) THEN RETURN; END;
  492.     WriteS (f, "| "); WI (TreeRoot^.Ag.TreeName); WriteS (f, "."); WI (Name); WriteS (f, ":"); WriteNl (f);
  493.     Class := t;
  494.     LOOP
  495.        IF Generated = InstCount THEN EXIT; END;
  496.        INC (Generated);
  497.        WITH Instance^ [Instance^ [Generated].Order] DO
  498.           IF (Left IN Properties) AND (Attribute^.Child.Partition > n) THEN
  499.              DEC (Generated); EXIT;
  500.           END;
  501.           IF ({Inherited, Right, First} <= Properties) AND NOT (Virtual IN Properties) THEN
  502.       IF IsElement (ORD ('X'), Options) AND (Trace IN t^.Class.Properties) THEN
  503.          WriteS (f, "yyWriteEval (yyt, '"); WI (Selector^.Child.Name); WriteS (f, ":"); WI (Attribute^.Child.Name); WriteS (f, "');"); WriteNl (f);
  504.          IF Action # ADR (Action) THEN GenEvaluator (Action); END; WriteNl (f);
  505.          IF (Attribute^.Kind = Tree.Child) OR (Attribute^.Attribute.Type = itTree) THEN
  506.             WriteS (f, "write"); WI (itTree);
  507.             WriteS (f, " (yyt^."); WI (Name); WriteS (f, "."); WI (Selector^.Child.Name);
  508.             WriteS (f, "^."); WI (Selector^.Child.Type); WriteS (f, "."); WI (Attribute^.Child.Name); WriteS (f, ")"); WriteNl (f);
  509.          ELSE
  510.             WriteS (f, "write"); WI (Attribute^.Child.Type);
  511.             WriteS (f, " (yyt^."); WI (Name); WriteS (f, "."); WI (Selector^.Child.Name);
  512.             WriteS (f, "^."); WI (Selector^.Child.Type); WriteS (f, "."); WI (Attribute^.Child.Name); WriteS (f, ") yyWriteNl;"); WriteNl (f);
  513.          END;
  514.       ELSIF IsElement (ORD ('Y'), Options) AND (Trace IN t^.Class.Properties) THEN
  515.          WriteS (f, "yyWriteEval (yyt, '"); WI (Selector^.Child.Name); WriteS (f, ":"); WI (Attribute^.Child.Name); WriteS (f, "');"); WriteNl (f);
  516.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  517.       ELSE
  518.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  519.       END;
  520.           END;
  521.           IF ({Synthesized, Left, First} <= Properties) AND ({Dummy, Virtual} * Properties = {}) THEN
  522.       IF IsElement (ORD ('X'), Options) AND (Trace IN t^.Class.Properties) THEN
  523.          WriteS (f, "yyWriteEval (yyt, '"); WI (Attribute^.Child.Name); WriteS (f, "');"); WriteNl (f);
  524.          IF Action # ADR (Action) THEN GenEvaluator (Action); END; WriteNl (f);
  525.          IF Test IN Properties THEN
  526.             WriteS (f, "writeBOOLEAN (yyb) yyWriteNl;"); WriteNl (f);
  527.          ELSIF (Attribute^.Kind = Tree.Child) OR (Attribute^.Attribute.Type = itTree) THEN
  528.             WriteS (f, "write"); WI (itTree);
  529.             WriteS (f, " (yyt^."); WI (Name); WriteS (f, "."); WI (Attribute^.Child.Name); WriteS (f, ")"); 
  530.          ELSE
  531.             WriteS (f, "write"); WI (Attribute^.Child.Type);
  532.             WriteS (f, " (yyt^."); WI (Name); WriteS (f, "."); WI (Attribute^.Child.Name); WriteS (f, ") yyWriteNl;"); WriteNl (f);
  533.          END;
  534.       ELSIF IsElement (ORD ('Y'), Options) AND (Trace IN t^.Class.Properties) THEN
  535.          WriteS (f, "yyWriteEval (yyt, '"); WI (Attribute^.Child.Name); WriteS (f, "');"); WriteNl (f);
  536.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  537.       ELSE
  538.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  539.       END;
  540.           END;
  541.           IF ({Synthesized, Right, First} <= Properties) AND
  542.          (Attribute^.Child.Partition <= Selector^.Child.Class^.Class.Visits) THEN
  543.       IF IsElement (ORD ('Z'), Options) AND (Trace IN t^.Class.Properties) THEN
  544.          WriteS (f, "yyWriteVisit (yyt, '"); WI (Selector^.Child.Name); WriteS (f, " "); 
  545.          WN (Attribute^.Child.Partition); WriteS (f, "');"); WriteNl (f);
  546.       END;
  547.          WriteS (f, "yyVisit"); WN (Attribute^.Child.Partition);
  548.          WriteS (f, " (yyt^."); WI (Name); WriteS (f, "."); WI (Selector^.Child.Name); WriteS (f, ");"); WriteNl (f);
  549.           END;
  550.        END;
  551.     END;
  552.       IF IsElement (ORD ('Z'), Options) AND (Trace IN t^.Class.Properties) THEN
  553.     WriteS (f, "yyVisitParent (yyt);"); WriteNl (f);
  554.       END;
  555. ;
  556.       RETURN;
  557.      END;
  558.    END;
  559.  
  560.   | Tree.Assign:
  561. (* line 349 "" *)
  562.      WITH t^.Assign DO
  563. (* line 349 "" *)
  564.       
  565.     WriteLine (Pos);
  566.     GenEvaluator (Results); WriteS (f, ":="); GenEvaluator (Arguments); WriteS (f, ";"); WriteNl (f);
  567. ;
  568.       RETURN;
  569.      END;
  570.  
  571.   | Tree.Copy:
  572. (* line 353 "" *)
  573.      WITH t^.Copy DO
  574. (* line 353 "" *)
  575.       
  576.     WriteLine (Pos);
  577.     GenEvaluator (Results); WriteS (f, ":="); GenEvaluator (Arguments); WriteS (f, ";"); WriteNl (f);
  578. ;
  579.       RETURN;
  580.      END;
  581.  
  582.   | Tree.TargetCode:
  583. (* line 357 "" *)
  584.      WITH t^.TargetCode DO
  585. (* line 357 "" *)
  586.       
  587.     WriteLine (Pos);
  588.     GenEvaluator (Code); WriteNl (f);
  589. ;
  590.       RETURN;
  591.      END;
  592.  
  593.   | Tree.Check:
  594. (* line 361 "" *)
  595.      WITH t^.Check DO
  596. (* line 361 "" *)
  597.       
  598.     WriteLine (Pos);
  599.     IF Condition # NoTree THEN
  600.       IF IsElement (ORD ('X'), Options) THEN
  601.        WriteS (f, "yyb := "); GenEvaluator (Condition); WriteS (f, "; IF NOT yyb THEN "); 
  602.       ELSE
  603.        WriteS (f, "IF NOT ("); GenEvaluator (Condition); WriteS (f, ") THEN "); 
  604.       END;
  605.        GenEvaluator (Statement); WriteNl (f);
  606.        IF Actions^.Kind = Tree.Check THEN
  607.           WriteS (f, "ELSE"); WriteNl (f);
  608.           GenEvaluator (Actions);
  609.        END;
  610.        WriteS (f, " END;"); WriteNl (f);
  611.     ELSE
  612.       IF IsElement (ORD ('X'), Options) THEN
  613.        WriteS (f, "yyb := FALSE; "); 
  614.       END;
  615.        GenEvaluator (Statement); WriteS (f, ";"); WriteNl (f);
  616.        GenEvaluator (Actions);
  617.     END;
  618. ;
  619.       RETURN;
  620.      END;
  621.  
  622.   | Tree.Designator:
  623. (* line 383 "" *)
  624.      WITH t^.Designator DO
  625. (* line 383 "" *)
  626.       
  627.     Attr := IdentifyAttribute (Class, Selector);
  628.     IF Attr # NoTree THEN
  629.        ChildsClass := Attr^.Child.Class;
  630.        Attr := IdentifyAttribute (ChildsClass, Attribute);
  631.        IF NOT (Virtual IN Attr^.Attribute.Properties) THEN
  632.           WriteS (f, "yyt^."); WI (Class^.Class.Name); WriteS (f, "."); 
  633.           WI (Selector); WriteS (f, "^."); WI (ChildsClass^.Class.Name); WriteS (f, "."); WI (Attribute);
  634.        END;
  635.     ELSE
  636.        WI (Selector); WriteS (f, ":"); WI (Attribute);
  637.     END;
  638.     GenEvaluator (Next);
  639. ;
  640.       RETURN;
  641.      END;
  642.  
  643.   | Tree.Ident:
  644. (* line 397 "" *)
  645.      WITH t^.Ident DO
  646. (* line 397 "" *)
  647.       
  648.     Attr := IdentifyAttribute (Class, Attribute);
  649.     IF Attr # NoTree THEN
  650.        IF NOT (Virtual IN Attr^.Attribute.Properties) THEN
  651.           WriteS (f, "yyt^."); WI (Class^.Class.Name); WriteS (f, "."); WI (Attribute);
  652.        END;
  653.     ELSE
  654.        WI (Attribute);
  655.     END;
  656.     GenEvaluator (Next);
  657. ;
  658.       RETURN;
  659.      END;
  660.  
  661.   | Tree.Remote:
  662. (* line 408 "" *)
  663.     WITH yyTempo.yyR8 DO
  664.      WITH t^.Remote DO
  665. (* line 409 "" *)
  666.       ;
  667. (* line 409 "" *)
  668.       ;
  669. (* line 410 "" *)
  670.       TheClass := IdentifyClass (TreeRoot ^ . Ag . Classes, Type);
  671. (* line 411 "" *)
  672.         IF TheClass # NoTree THEN
  673.       Attr := IdentifyAttribute (TheClass, Attribute);
  674.       IF Attr # NoTree THEN
  675.      WITH Attr^.Attribute DO
  676.         k := ToBit0 (TheClass, AttrIndex);
  677.         IF Synthesized IN Properties THEN
  678.            WriteS (f, "REMOTE_SYN (yyIsComp"); WN (k DIV BSS); WriteS (f, ", "); WN (k MOD BSS); WriteS (f, ", yyS"); WN (k); WriteS (f, ", "); 
  679.            GenEvaluator (Designators); WriteS (f, ", "); WI (t^.Remote.Type); WriteS (f, ", "); WI (Attribute); WriteS (f, ")"); 
  680.         ELSIF Inherited IN Properties THEN
  681.            WriteS (f, "REMOTE_INH (yyIsComp"); WN (k DIV BSS); WriteS (f, ", "); WN (k MOD BSS); WriteS (f, ", "); WN (k); WriteS (f, ", "); 
  682.            GenEvaluator (Designators); WriteS (f, ", "); WI (t^.Remote.Type); WriteS (f, ", "); WI (Attribute); WriteS (f, ")"); 
  683.         ELSE
  684.            GenEvaluator (Designators); WriteS (f, "^."); WI (t^.Remote.Type); WriteS (f, "."); WI (Attribute);
  685.         END;
  686.      END;
  687.       END;
  688.    END;
  689.    GenEvaluator (Next);
  690. ;
  691.       RETURN;
  692.      END;
  693.     END;
  694.  
  695.   | Tree.Any:
  696. (* line 430 "" *)
  697.      WITH t^.Any DO
  698. (* line 430 "" *)
  699.       
  700.     WriteString (f, Code);
  701.     GenEvaluator (Next);
  702. ;
  703.       RETURN;
  704.      END;
  705.  
  706.   | Tree.Anys:
  707. (* line 434 "" *)
  708.      WITH t^.Anys DO
  709. (* line 434 "" *)
  710.       
  711.     GenEvaluator (Layouts);
  712.     GenEvaluator (Next);
  713. ;
  714.       RETURN;
  715.      END;
  716.  
  717.   | Tree.LayoutAny:
  718. (* line 438 "" *)
  719.      WITH t^.LayoutAny DO
  720. (* line 438 "" *)
  721.       
  722.     WriteString (f, Code);
  723.     GenEvaluator (Next);
  724. ;
  725.       RETURN;
  726.      END;
  727.  
  728.   ELSE END;
  729.  
  730.  END GenEvaluator;
  731.  
  732. PROCEDURE BeginEvalMod;
  733.  BEGIN
  734.  END BeginEvalMod;
  735.  
  736. PROCEDURE CloseEvalMod;
  737.  BEGIN
  738.  END CloseEvalMod;
  739.  
  740. PROCEDURE yyExit;
  741.  BEGIN
  742.   IO.CloseIO; System.Exit (1);
  743.  END yyExit;
  744.  
  745. BEGIN
  746.  yyf    := IO.StdOutput;
  747.  Exit    := yyExit;
  748.  BeginEvalMod;
  749. END EvalMod.
  750.